home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / tick.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  3.9 KB  |  132 lines
  1. /*  linux/include/linux/tick.h
  2.  *
  3.  *  This file contains the structure definitions for tick related functions
  4.  *
  5.  */
  6. #ifndef _LINUX_TICK_H
  7. #define _LINUX_TICK_H
  8.  
  9. #include <linux/clockchips.h>
  10.  
  11. #ifdef CONFIG_GENERIC_CLOCKEVENTS
  12.  
  13. enum tick_device_mode {
  14.     TICKDEV_MODE_PERIODIC,
  15.     TICKDEV_MODE_ONESHOT,
  16. };
  17.  
  18. struct tick_device {
  19.     struct clock_event_device *evtdev;
  20.     enum tick_device_mode mode;
  21. };
  22.  
  23. enum tick_nohz_mode {
  24.     NOHZ_MODE_INACTIVE,
  25.     NOHZ_MODE_LOWRES,
  26.     NOHZ_MODE_HIGHRES,
  27. };
  28.  
  29. /**
  30.  * struct tick_sched - sched tick emulation and no idle tick control/stats
  31.  * @sched_timer:    hrtimer to schedule the periodic tick in high
  32.  *            resolution mode
  33.  * @idle_tick:        Store the last idle tick expiry time when the tick
  34.  *            timer is modified for idle sleeps. This is necessary
  35.  *            to resume the tick timer operation in the timeline
  36.  *            when the CPU returns from idle
  37.  * @tick_stopped:    Indicator that the idle tick has been stopped
  38.  * @idle_jiffies:    jiffies at the entry to idle for idle time accounting
  39.  * @idle_calls:        Total number of idle calls
  40.  * @idle_sleeps:    Number of idle calls, where the sched tick was stopped
  41.  * @idle_entrytime:    Time when the idle call was entered
  42.  * @idle_waketime:    Time when the idle was interrupted
  43.  * @idle_exittime:    Time when the idle state was left
  44.  * @idle_sleeptime:    Sum of the time slept in idle with sched tick stopped
  45.  * @sleep_length:    Duration of the current idle sleep
  46.  */
  47. struct tick_sched {
  48.     struct hrtimer            sched_timer;
  49.     unsigned long            check_clocks;
  50.     enum tick_nohz_mode        nohz_mode;
  51.     ktime_t                idle_tick;
  52.     int                inidle;
  53.     int                tick_stopped;
  54.     unsigned long            idle_jiffies;
  55.     unsigned long            idle_calls;
  56.     unsigned long            idle_sleeps;
  57.     int                idle_active;
  58.     ktime_t                idle_entrytime;
  59.     ktime_t                idle_waketime;
  60.     ktime_t                idle_exittime;
  61.     ktime_t                idle_sleeptime;
  62.     ktime_t                idle_lastupdate;
  63.     ktime_t                sleep_length;
  64.     unsigned long            last_jiffies;
  65.     unsigned long            next_jiffies;
  66.     ktime_t                idle_expires;
  67. };
  68.  
  69. extern void __init tick_init(void);
  70. extern int tick_is_oneshot_available(void);
  71. extern struct tick_device *tick_get_device(int cpu);
  72.  
  73. # ifdef CONFIG_HIGH_RES_TIMERS
  74. extern int tick_init_highres(void);
  75. extern int tick_program_event(ktime_t expires, int force);
  76. extern void tick_setup_sched_timer(void);
  77. # endif
  78.  
  79. # if defined CONFIG_NO_HZ || defined CONFIG_HIGH_RES_TIMERS
  80. extern void tick_cancel_sched_timer(int cpu);
  81. # else
  82. static inline void tick_cancel_sched_timer(int cpu) { }
  83. # endif
  84.  
  85. # ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
  86. extern struct tick_device *tick_get_broadcast_device(void);
  87. extern cpumask_t *tick_get_broadcast_mask(void);
  88.  
  89. #  ifdef CONFIG_TICK_ONESHOT
  90. extern cpumask_t *tick_get_broadcast_oneshot_mask(void);
  91. #  endif
  92.  
  93. # endif /* BROADCAST */
  94.  
  95. # ifdef CONFIG_TICK_ONESHOT
  96. extern void tick_clock_notify(void);
  97. extern int tick_check_oneshot_change(int allow_nohz);
  98. extern struct tick_sched *tick_get_tick_sched(int cpu);
  99. extern void tick_check_idle(int cpu);
  100. # else
  101. static inline void tick_clock_notify(void) { }
  102. static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
  103. static inline void tick_check_idle(int cpu) { }
  104. # endif
  105.  
  106. #else /* CONFIG_GENERIC_CLOCKEVENTS */
  107. static inline void tick_init(void) { }
  108. static inline void tick_cancel_sched_timer(int cpu) { }
  109. static inline void tick_clock_notify(void) { }
  110. static inline int tick_check_oneshot_change(int allow_nohz) { return 0; }
  111. static inline void tick_check_idle(int cpu) { }
  112. #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
  113.  
  114. # ifdef CONFIG_NO_HZ
  115. extern void tick_nohz_stop_sched_tick(int inidle);
  116. extern void tick_nohz_restart_sched_tick(void);
  117. extern ktime_t tick_nohz_get_sleep_length(void);
  118. extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);
  119. # else
  120. static inline void tick_nohz_stop_sched_tick(int inidle) { }
  121. static inline void tick_nohz_restart_sched_tick(void) { }
  122. static inline ktime_t tick_nohz_get_sleep_length(void)
  123. {
  124.     ktime_t len = { .tv64 = NSEC_PER_SEC/HZ };
  125.  
  126.     return len;
  127. }
  128. static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
  129. # endif /* !NO_HZ */
  130.  
  131. #endif
  132.